Determining which values in a first set of values are members of a second set of values may be computationally expensive. The larger the first set and/or the second set is, the more time is required to determine which values in the first set of values are members of a second set of values. For purposes of illustrating a clear example, assume the following:                A database has a table named “OrbitingObjects”, which has a particular column named “Type”; and        A database server receives the following query: “SELECT count(Type) FROM OrbitingObjects WHERE Type=‘rocket’ OR Type=‘station’;”.        
To respond to the query, the database server must determine which values in the particular column are members of a second set. In this case, the second set is the set of values that match “rocket” or “station”. The more rows in the column Type, the longer the database server may take to determine which rows in the Type column satisfy the condition: “WHERE Type=‘rocket’ OR Type=‘station’”.
Furthermore, some types of conditions are computationally expensive. For instance, in the previous example, the database server may perform a string comparison between each value in the Type column and the two condition values: “rocket” and “station”.
Some database systems rely on using newer processing units with higher processing speeds to determine which rows in a column satisfy one or more conditions in a query and return results more quickly. However, the performance of typical processing units is not increasing at the same rate as the quantity of the data upon which database operations are performed. Thus, database and other software developers are not able to rely as much on increasing computer power to more quickly evaluate which values in a first set of values are members of a second set of values.
Single instruction multiple data (“SIMD”) processors perform the same operation on multiple data items simultaneously. SIMD processors exploit data level parallelism by executing a single instruction against data in multiple registers or subregisters. Thus, the throughput per instruction may be increased accordingly.
SIMD processors are typically used for graphic and other multimedia applications. Exploiting the SIMD architecture to evaluate which values in a first set of values are members of a second set of values may be difficult. For example, many SIMD processors cannot branch to a first operation after evaluating a first value in a first subregister, and branch to a second operation after evaluating a second value in a second subregister, in parallel. Thus, if a first column value satisfies a condition, but a second column value does not satisfy the same condition, then some SIMD architectures do not have a mechanism to branch to a first operation to indicate the particular column value satisfied the condition, while branching in parallel to a second operation to indicate the second column value did not satisfy the condition.
The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section.